$import("com.joypard.platform.organization.org.OrgDI");
$import("com.joypard.platform.organization.post.PostView");
$import("com.joypard.platform.organization.job.JobView");
$import("com.joypard.platform.organization.org.UserView");

/**
 * 定义组织机构视图
 */
K.defView("com.joypard.platform.organization.org.OrgView", {
	organizationView : null, // 构造参数

	/**
	 * 权限配置
	 */
	purviewConfig : {
		view : "platform.organization.org",
		addOrg : "platform.organization.org.addOrg",
		updateOrg : "platform.organization.org.updateOrg",
		delOrg : "platform.organization.org.delOrg"
	},

	/**
	 * 构造方法
	 * 
	 * @param organizationView
	 *            组织视图
	 */
	OrgView : function(organizationView) {
		this.organizationView = organizationView;
		E.addEvents("组织机构树-单击", "组织-新增", "组织-修改", "组织-删除", "组织-信息改变");
		E.addListener("组织-新增-成功", this.onAddOrgSuccessEvent, this);
		E.addListener("组织-修改-成功", this.onUpdateOrgSuccessEvent, this);
		E.addListener("组织-删除-成功", this.onDelOrgSuccessEvent, this);
	},

	/**
	 * 获取组织机构树
	 * 
	 * @returns
	 */
	getOrgTreePanel : function() {
		return this.organizationView.orgTreePanel;
	},

	/**
	 * 获取组织机构编辑面板
	 * 
	 * @returns
	 */
	getOrgEditPanel : function() {
		return this.organizationView.orgEditPanel;
	},

	/**
	 * 创建组织信息，用于编辑、显示组织信息<br>
	 * region:center
	 */
	createOrgEditPanel : function() {
		var options = {
			title : "组织信息",
			iconCls : "p-edit",
			autoScroll : true,
			margins : "2 2 2 0",
			region : "center",
			tbar : {
				xtype : "toolbar",
				hidden : !OrgView.purviewAddOrg() && !OrgView.purviewUpdateOrg() && !OrgView.purviewDelOrg(),
				items : [ {
					text : "保存",
					hidden : !OrgView.purviewAddOrg() && !OrgView.purviewUpdateOrg(),
					iconCls : "save",
					handler : K.createDelegate(this.onSaveOrg, this)
				}, {
					text : "新增",
					hidden : !OrgView.purviewAddOrg(),
					iconCls : 'add',

					handler : K.createDelegate(this.onAddOrg, this)
				}, {
					text : "删除",
					iconCls : 'delete',
					hidden : !OrgView.purviewDelOrg(),
					handler : K.createDelegate(this.onDelOrg, this)
				} ]
			}
		};
		return new K.Ext.Panel(options);
	},
	/**
	 * 创建附加标签页面板,包括岗位信息、职位信息、用户信息 <br>
	 * region:east
	 */
	createAttachTabPanel : function() {
		var options = {
			title : "标签页",
			region : "east",
			margins : "2 2 3 0",
			width : "43%"
		};
		this.attachTabPanel = new K.Ext.TabPanel(options);

		// 添加标签
		if (PostView.purview()) {
			this.attachTabPanel.add(this.postView.createPostPanel());
		}
		if (JobView.purview()) {
			this.attachTabPanel.add(this.jobView.createJobPanel());
		}
		if (UserView.purview()) {
			this.attachTabPanel.add(this.userView.createUserPanel());
		}

		this.attachTabPanel.activate(0);
		return this.attachTabPanel;
	},

	/** ------ ------ ------ ------ 事件/监听 ------ ------ ------ ------ */
	/**
	 * 保存<br>
	 * 新增/修改通过判断当前form的state属性
	 */
	onSaveOrg : function() {
		var $form = $("form", this.getOrgEditPanel().getEl().dom);
		var state = $form.attr("state"), eventName = null;
		if (state == K.state.update) {
			if (OrgView.purviewUpdateOrg()) {
				eventName = "组织-修改";
			} else {
				K.noright(this.getOrgEditPanel().tbar);
			}
		} else if (state == K.state.add) {
			if (OrgView.purviewAddOrg()) {
				eventName = "组织-新增";
			} else {
				K.noright(this.getOrgEditPanel().tbar);
			}
		}
		if (eventName) {
			E.fireEvent(eventName, $form);
		}
	},
	/**
	 * 新增<br>
	 * 加载新增视图,如果选择组织机构树点击新增,则新增界面上的上级组织默认为当前选择的组织
	 */
	onAddOrg : function(button, eventObject) {
		var node = this.getOrgSelectTreeNode(), params = {};
		if (node) {
			params.parentOrgId = node.id;
		}
		this.getOrgEditPanel().load({
			method : "GET",
			scripts : true,
			url : OrgDI.urls.addOrg,
			params : params
		});
	},
	/**
	 * 删除<br>
	 * 当前选择的组织节点
	 */
	onDelOrg : function() {
		var node = this.getOrgSelectTreeNode();
		if (node) {
			if (!confirm("删除该组织同时会删除下级组织，您确定要删除吗?")) {
				return false;
			}
			E.fireEvent("组织-删除", node);
		} else {
			K.err("请选择要删除的组织节点");
		}
	},
	/**
	 * 新增组织成功<br>
	 * 添加新的组织信息到组织树中<br>
	 * 添加后如果上级组织的子节点长度为1则展开,重新加载组织编辑面板信息,状态变为修改状态
	 */
	onAddOrgSuccessEvent : function(output) {
		var newOrg = output.getParameter("org");
		this._loadOrgInfoToOrgEditPanel(newOrg.id);
		var parentOrgNode = K.Ext.flyTree(this.getOrgTreePanel()).getNodeById(newOrg.parentOrg);
		if (parentOrgNode) {
			newOrg.text = newOrg.text || newOrg.name, newOrg.leaf = newOrg.leaf == 1, newOrg.children = null;
			parentOrgNode.appendChild(new K.Ext.tree.TreeNode(newOrg));
			if (parentOrgNode.childNodes.length == 1) {
				parentOrgNode.expand();
			}
		}
		K.msg("新增组织信息成功", this.getOrgEditPanel().tbar);
	},
	/**
	 * 更新组织信息成功<br>
	 * 更新组织树对应的组织节点信息
	 */
	onUpdateOrgSuccessEvent : function(output) {
		var org = output.getParameter("org");
		var orgNode = K.Ext.flyTree(this.getOrgTreePanel()).setNodeText(org).getNodeById(org.id);
		E.fireEvent("组织-信息改变", orgNode);
		K.m("修改组织信息成功").show(this.getOrgEditPanel().tbar);
	},
	/**
	 * 删除组织节点成功<br>
	 * 把该节点移出组织树,同时点击被删除的组织节点最近的一个组织节点(以前后跟顺序查找)
	 */
	onDelOrgSuccessEvent : function(output) {
		var node = K.Ext.flyTree(this.getOrgTreePanel()).getNodeById(output.getParameter("orgId"));
		var clickNode = node.previousSibling || node.nextSibling || node.parentNode;
		node.remove();
		this.getOrgTreePanel().fireEvent("click", clickNode);
	},
	/**
	 * 组织机构树节点单击事件<br>
	 * 自动加载当前组织节点信息到编辑面板内容中
	 */
	onTreePanelClick : function(selModel, node) {
		if (node) {
			this._loadOrgInfoToOrgEditPanel(node.id);
			E.fireEvent("组织机构树-单击", node);
		}
	},

	/** ------ ------ ------ ------ 函数定义 ------ ------ ------ ------ */
	/**
	 * 获取当前组织树被选中的组织节点
	 */
	getOrgSelectTreeNode : function() {
		return this.getOrgTreePanel().getSelectionModel().getSelectedNode();
	},
	/**
	 * 加载组织信息到编辑面板中
	 */
	_loadOrgInfoToOrgEditPanel : function(orgId) {
		this.getOrgEditPanel().load({
			method : "GET",
			scripts : true,
			url : OrgDI.urls.updateOrg,
			params : {
				orgId : orgId
			}
		});
	},

	/**
	 * 创建一个组织机构下拉树
	 */
	createOrgTreeCombo : function(config) {
		var options = K.extend({
			checkModel : 'single'
		}, config);
		alert("->" + options.root);
		options.root = options.root || OrgDI.getRootOrgInfo(); // 请放心这样写不会额外的去加载数据
		options.loader = options.loader || this.createOrgTreeLoader();
		return new Ext.ux.TreeCombo(options);
	},

	/**
	 * 获取组织机构树加载器
	 */
	createOrgTreeLoader : function() {
		var loader = new K.Ext.tree.TreeLoader({
			url : OrgDI.urls.getOrgChildrens,
			requestMethod : "GET",
			baseParams : {
				parentOrgId : "0"
			},
			listeners : {
				beforeload : function(loader, node) {
					this.baseParams.parentOrgId = node.id;
				}
			},
			filterTreeData : function(obj) {
				var output = K.createOutput(obj);
				return output.getParameter("orgs");
			},
			createNode : function(attr) {
				attr.text = attr.name;
				return K.Ext.tree.TreeLoader.prototype.createNode.call(this, attr);
			}
		});
		return loader;
	},

	/**
	 * 创建组织机构树
	 * 
	 * @param config
	 * @returns {K.Ext.tree.TreePanel}
	 */
	createOrgTreePanel : function(config) {
		var options = {
			title : "组织机构树",
			frame : true,
			iconCls : "p-panel",
			autoScroll : true,
			region : "west",
			margins : "2 2 3 2",
			width : "20%",
			loader : this.createOrgTreeLoader()
		};
		K.extend(options, config);

		var treePanel = new K.Ext.tree.TreePanel(options);
		var rootNode = this.createOrgAsyncRootNode();
		if (rootNode != null) {
			treePanel.setRootNode(this.createOrgAsyncRootNode());
		}
		treePanel.getSelectionModel().on("selectionchange", this.onTreePanelClick, this);
		return treePanel;
	},

	/** ------ ------ ------ ------ 加载器 ------ ------ ------ ------ */
	/**
	 * 创建一个异步根组织信息<br>
	 * 
	 * @param rootCode
	 *            根节点编码
	 */
	createOrgAsyncRootNode : function(rootCode) {
		var rootInfo = OrgDI.getRootOrgInfo(rootCode, false);
		if (!rootInfo) {
			return;
		}
		rootInfo.text = rootInfo.name;
		rootInfo.leaf = rootInfo.leaf == 1;
		return new K.Ext.tree.AsyncTreeNode(rootInfo);
	}
});